home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / comm2 / termsorc.lha / Extras / Source / term-source.lha / termPickFile.c < prev    next >
C/C++ Source or Header  |  1995-09-28  |  15KB  |  738 lines
  1. /*
  2. **    termPickFile.c
  3. **
  4. **    Simplified file selection routines
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. #include <exec/resident.h>
  13.  
  14. enum    {    GAD_LIST=1,GAD_USE,GAD_SELECT,GAD_CANCEL };
  15.  
  16. BOOLEAN __regargs
  17. ValidateFile(STRPTR FileName,LONG Type,STRPTR RealName)
  18. {
  19.     BOOLEAN    Valid = FALSE;
  20.     BPTR    Segment;
  21.  
  22.     if(Segment = LoadSeg(FileName))
  23.     {
  24.         ULONG    *SegmentData;
  25.         BPTR     SegPtr = Segment;
  26.         UWORD    *Match;
  27.         BOOLEAN     GotIt = FALSE;
  28.         LONG     Size;
  29.  
  30.         do
  31.         {
  32.             SegmentData = (ULONG *)BADDR(SegPtr);
  33.  
  34.             SegPtr    = (BPTR)SegmentData[0];
  35.             Size    = SegmentData[-1] - 2 * sizeof(ULONG) - sizeof(struct Resident);
  36.             Match    = (UWORD *)(SegmentData + 1);
  37.  
  38.             while(!GotIt && Size > 0)
  39.             {
  40.                 if(*Match == RTC_MATCHWORD)
  41.                 {
  42.                     struct Resident *Resident = (struct Resident *)Match;
  43.  
  44.                     if(Resident -> rt_MatchTag == Resident)
  45.                     {
  46.                         if(Resident -> rt_Type == Type && Resident -> rt_Name)
  47.                         {
  48.                             if(!Stricmp(FilePart(FileName),Resident -> rt_Name))
  49.                             {
  50.                                 if(RealName)
  51.                                     strcpy(RealName,Resident -> rt_Name);
  52.  
  53.                                 Valid = TRUE;
  54.                             }
  55.                         }
  56.  
  57.                         GotIt = TRUE;
  58.                     }
  59.                 }
  60.  
  61.                 Match    += 2;
  62.                 Size    -= sizeof(ULONG);
  63.             }
  64.         }
  65.         while(!GotIt && SegPtr);
  66.  
  67.         UnLoadSeg(Segment);
  68.     }
  69.  
  70.     return(Valid);
  71. }
  72.  
  73.     /* AddFile(struct List *List,STRPTR Name):
  74.      *
  75.      *    Add another file to the list:
  76.      */
  77.  
  78. STATIC VOID __regargs
  79. AddFile(struct List *List,STRPTR Name)
  80. {
  81.     struct Node *NewNode;
  82.  
  83.     if(NewNode = CreateNode(Name))
  84.     {
  85.         struct Node    *Node,
  86.                 *Next;
  87.         BYTE         GotIt = FALSE;
  88.         LONG         Result;
  89.  
  90.         Node = List -> lh_Head;
  91.  
  92.         while(Next = Node -> ln_Succ)
  93.         {
  94.             if((Result = Stricmp(Name,Node -> ln_Name)) < 0)
  95.             {
  96.                 Insert(List,NewNode,Node -> ln_Pred);
  97.  
  98.                 GotIt = TRUE;
  99.  
  100.                 break;
  101.             }
  102.             else
  103.             {
  104.                     /* Don't add two identical names. */
  105.  
  106.                 if(!Result)
  107.                 {
  108.                     FreeVecPooled(NewNode);
  109.  
  110.                     return;
  111.                 }
  112.             }
  113.  
  114.             Node = Next;
  115.         }
  116.  
  117.         if(!GotIt)
  118.             AddTail(List,NewNode);
  119.     }
  120. }
  121.  
  122.     /* FileMultiScan(struct List *FileList,STRPTR Directory,STRPTR Pattern):
  123.      *
  124.      *    Scan an assignment, also handles multipath assignments.
  125.      */
  126.  
  127. STATIC VOID __regargs
  128. FileMultiScan(struct List *FileList,STRPTR Directory,STRPTR Pattern,LONG Type)
  129. {
  130.     struct DevProc        *DevProc    = NULL;
  131.     struct MsgPort        *FileSysTask    = GetFileSysTask();
  132.     struct FileInfoBlock    *FileInfo;
  133.     UBYTE             MatchBuffer[MAX_FILENAME_LENGTH];
  134.  
  135.     if(ParsePatternNoCase(Pattern,MatchBuffer,MAX_FILENAME_LENGTH) != -1)
  136.     {
  137.             /* Allocate the fileinfo data. */
  138.  
  139.         if(FileInfo = (struct FileInfoBlock *)AllocDosObjectTags(DOS_FIB,TAG_DONE))
  140.         {
  141.                 /* Loop until all assignments are
  142.                  * processed.
  143.                  */
  144.  
  145.             do
  146.             {
  147.                     /* Get the default filesystem task
  148.                      * in case we stumble upon NULL
  149.                      * directory locks.
  150.                      */
  151.  
  152.                 if(DevProc = GetDeviceProc(Directory,DevProc))
  153.                 {
  154.                         /* Set the default filesystem task. */
  155.  
  156.                     SetFileSysTask(DevProc -> dvp_Port);
  157.  
  158.                         /* Check the object type. */
  159.  
  160.                     if(Examine(DevProc -> dvp_Lock,FileInfo))
  161.                     {
  162.                             /* Is it really a directory? */
  163.  
  164.                         if(FileInfo -> fib_DirEntryType > 0)
  165.                         {
  166.                                 /* Scan the directory... */
  167.  
  168.                             while(ExNext(DevProc -> dvp_Lock,FileInfo))
  169.                             {
  170.                                     /* Did we find a file? */
  171.  
  172.                                 if(FileInfo -> fib_DirEntryType < 0)
  173.                                 {
  174.                                         /* Does the name match the template? */
  175.  
  176.                                     if(MatchPatternNoCase(MatchBuffer,FileInfo -> fib_FileName))
  177.                                     {
  178.                                         if(Type == -1)
  179.                                             AddFile(FileList,FileInfo -> fib_FileName);
  180.                                         else
  181.                                         {
  182.                                             UBYTE LocalBuffer[MAX_FILENAME_LENGTH],RealName[MAX_FILENAME_LENGTH];
  183.  
  184.                                             strcpy(LocalBuffer,Directory);
  185.  
  186.                                             if(AddPart(LocalBuffer,FileInfo -> fib_FileName,MAX_FILENAME_LENGTH))
  187.                                             {
  188.                                                 if(ValidateFile(LocalBuffer,Type,RealName))
  189.                                                     AddFile(FileList,RealName);
  190.                                             }
  191.                                         }
  192.                                     }
  193.                                 }
  194.                             }
  195.                         }
  196.                     }
  197.                 }
  198.                 else
  199.                     break;
  200.             }
  201.             while(DevProc && (DevProc -> dvp_Flags & DVPF_ASSIGN));
  202.  
  203.                 /* Free the fileinfo data. */
  204.  
  205.             FreeDosObject(DOS_FIB,FileInfo);
  206.         }
  207.     }
  208.  
  209.         /* Reset the default filesystem task. */
  210.  
  211.     SetFileSysTask(FileSysTask);
  212.  
  213.         /* Free device process data. */
  214.  
  215.     if(DevProc)
  216.         FreeDeviceProc(DevProc);
  217. }
  218.  
  219.     /* FreeFileList(struct List *List):
  220.      *
  221.      *    Free a list and list contents.
  222.      */
  223.  
  224. STATIC VOID __regargs
  225. FreeFileList(struct List *List)
  226. {
  227.     struct Node    *Node,
  228.             *Next;
  229.  
  230.     Node = List -> lh_Head;
  231.  
  232.     while(Next = Node -> ln_Succ)
  233.     {
  234.         FreeVecPooled(Node);
  235.  
  236.         Node = Next;
  237.     }
  238.  
  239.     FreeVecPooled(List);
  240. }
  241.  
  242.     /* BuildFileList(STRPTR Directory,STRPTR Pattern):
  243.      *
  244.      *    Build a list of files in an assigned directory
  245.      *    matching a certain pattern.
  246.      */
  247.  
  248. STATIC struct List * __regargs
  249. BuildFileList(STRPTR Directory,STRPTR Pattern,LONG Type)
  250. {
  251.     APTR         OldPtr = ThisProcess -> pr_WindowPtr;
  252.     struct List    *FileList = NULL;
  253.     BPTR         NewDir;
  254.  
  255.         /* No DOS requesters, please! */
  256.  
  257.     ThisProcess -> pr_WindowPtr = (APTR)-1;
  258.  
  259.         /* Is the assignment present? */
  260.  
  261.     if(NewDir = Lock(Directory,ACCESS_READ))
  262.     {
  263.             /* Allocate space for the new list. */
  264.  
  265.         if(FileList = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  266.         {
  267.                 /* Initialize the list. */
  268.  
  269.             NewList(FileList);
  270.  
  271.                 /* Will we have to deal with
  272.                  * an assignment or a volume?
  273.                  */
  274.  
  275.             if(IsAssign(Directory))
  276.                 FileMultiScan(FileList,Directory,Pattern,Type);
  277.             else
  278.             {
  279.                 struct FileInfoBlock    *FileInfo;
  280.                 UBYTE             MatchBuffer[MAX_FILENAME_LENGTH];
  281.  
  282.                 if(ParsePatternNoCase(Pattern,MatchBuffer,MAX_FILENAME_LENGTH) != -1)
  283.                 {
  284.                         /* Allocate space for a fileinfo block. */
  285.  
  286.                     if(FileInfo = (struct FileInfoBlock *)AllocDosObjectTags(DOS_FIB,TAG_DONE))
  287.                     {
  288.                             /* Take a look at the assignment. */
  289.  
  290.                         if(Examine(NewDir,FileInfo))
  291.                         {
  292.                                 /* Does it really refer to a directory? */
  293.  
  294.                             if(FileInfo -> fib_DirEntryType > 0)
  295.                             {
  296.                                     /* Examine the whole directory. */
  297.  
  298.                                 while(ExNext(NewDir,FileInfo))
  299.                                 {
  300.                                         /* Is it a file? */
  301.  
  302.                                     if(FileInfo -> fib_DirEntryType < 0)
  303.                                     {
  304.                                         if(MatchPatternNoCase(MatchBuffer,FileInfo -> fib_FileName))
  305.                                         {
  306.                                             if(Type == -1)
  307.                                                 AddFile(FileList,FileInfo -> fib_FileName);
  308.                                             else
  309.                                             {
  310.                                                 UBYTE LocalBuffer[MAX_FILENAME_LENGTH],RealName[MAX_FILENAME_LENGTH];
  311.  
  312.                                                 strcpy(LocalBuffer,Directory);
  313.  
  314.                                                 if(AddPart(LocalBuffer,FileInfo -> fib_FileName,MAX_FILENAME_LENGTH))
  315.                                                 {
  316.                                                     if(ValidateFile(LocalBuffer,Type,RealName))
  317.                                                         AddFile(FileList,RealName);
  318.                                                 }
  319.                                             }
  320.                                         }
  321.                                     }
  322.                                 }
  323.                             }
  324.                         }
  325.  
  326.                             /* Free the fileinfo data. */
  327.  
  328.                         FreeDosObject(DOS_FIB,FileInfo);
  329.                     }
  330.                 }
  331.             }
  332.  
  333.             if(Type == NT_DEVICE)
  334.             {
  335.                 UBYTE MatchBuffer[MAX_FILENAME_LENGTH];
  336.  
  337.                 if(ParsePatternNoCase(Pattern,MatchBuffer,MAX_FILENAME_LENGTH) != -1)
  338.                 {
  339.                     struct Node *Node;
  340.  
  341.                     Forbid();
  342.  
  343.                     for(Node = SysBase -> DeviceList . lh_Head ; Node -> ln_Succ ; Node = Node -> ln_Succ)
  344.                     {
  345.                         if(MatchPatternNoCase(MatchBuffer,Node -> ln_Name))
  346.                             AddFile(FileList,Node -> ln_Name);
  347.                     }
  348.  
  349.                     Permit();
  350.                 }
  351.             }
  352.  
  353.             if(Type == NT_LIBRARY)
  354.             {
  355.                 UBYTE MatchBuffer[MAX_FILENAME_LENGTH];
  356.  
  357.                 if(ParsePatternNoCase(Pattern,MatchBuffer,MAX_FILENAME_LENGTH) != -1)
  358.                 {
  359.                     struct Node *Node;
  360.  
  361.                     Forbid();
  362.  
  363.                     for(Node = SysBase -> LibList . lh_Head ; Node -> ln_Succ ; Node = Node -> ln_Succ)
  364.                     {
  365.                         if(MatchPatternNoCase(MatchBuffer,Node -> ln_Name))
  366.                             AddFile(FileList,Node -> ln_Name);
  367.                     }
  368.  
  369.                     Permit();
  370.                 }
  371.             }
  372.  
  373.                 /* Does the list contain any entries? */
  374.  
  375.             if(!FileList -> lh_Head -> ln_Succ)
  376.             {
  377.                 FreeVecPooled(FileList);
  378.  
  379.                 FileList = NULL;
  380.             }
  381.         }
  382.  
  383.             /* Release the lock on the directory. */
  384.  
  385.         UnLock(NewDir);
  386.     }
  387.  
  388.         /* Enable DOS requesters again. */
  389.  
  390.     ThisProcess -> pr_WindowPtr = OldPtr;
  391.  
  392.         /* Return the file name list. */
  393.  
  394.     return(FileList);
  395. }
  396.  
  397.     /* PickFile(STRPTR Directory,STRPTR Pattern,STRPTR Prompt,STRPTR Name):
  398.      *
  399.      *    Your nice file selection routine. No need to hunt for
  400.      *    a library/device by checking all assignments by hand.
  401.      */
  402.  
  403. BYTE __regargs
  404. PickFile(struct Window *Window,STRPTR Directory,STRPTR Pattern,STRPTR Prompt,STRPTR Name,LONG Type)
  405. {
  406.     UBYTE              DummyBuffer[MAX_FILENAME_LENGTH],
  407.                 *DummyChar;
  408.     struct FileRequester    *FileRequest;
  409.     struct List        *FileList;
  410.     BYTE             Result = FALSE;
  411.  
  412.     if(FileList = BuildFileList(Directory,Pattern,Type))
  413.     {
  414.         struct LayoutHandle *Handle;
  415.  
  416.         if(Handle = LT_CreateHandleTags(Window -> WScreen,
  417.             LH_LocaleHook,    &LocaleHook,
  418.         TAG_DONE))
  419.         {
  420.             struct Window    *PanelWindow;
  421.             ULONG         Index = (ULONG)~0,i;
  422.             struct Node    *Node;
  423.  
  424.             for(Node = FileList -> lh_Head, i = 0 ; Node -> ln_Succ ; Node = Node -> ln_Succ, i++)
  425.             {
  426.                 if(!Stricmp(Node -> ln_Name,Name))
  427.                 {
  428.                     Index = i;
  429.  
  430.                     break;
  431.                 }
  432.             }
  433.  
  434.             LT_New(Handle,
  435.                 LA_Type,    VERTICAL_KIND,
  436.             TAG_DONE);
  437.             {
  438.                 LT_New(Handle,
  439.                     LA_Type,    VERTICAL_KIND,
  440. //                    LA_LabelID,    MSG_V36_1269,
  441.                 TAG_DONE);
  442.                 {
  443.                     LONG MaxWidth,MaxHeight;
  444.  
  445.                     MaxWidth = MaxHeight = 0;
  446.  
  447.                     if(FileList)
  448.                     {
  449.                         struct Node *Node;
  450.                         LONG Len;
  451.  
  452.                         for(Node = FileList -> lh_Head ; Node -> ln_Succ ; Node = Node -> ln_Succ)
  453.                         {
  454.                             Len = strlen(Node -> ln_Name);
  455.  
  456.                             if(Len > MaxWidth)
  457.                                 MaxWidth = Len;
  458.  
  459.                             MaxHeight++;
  460.                         }
  461.                     }
  462.  
  463.                     if(MaxWidth < 30)
  464.                         MaxWidth = 30;
  465.  
  466.                     if(MaxHeight < 10)
  467.                         MaxHeight = 10;
  468.                     else
  469.                     {
  470.                         if(MaxHeight > 20)
  471.                             MaxHeight = 20;
  472.                     }
  473.  
  474.                     LT_New(Handle,
  475.                         LA_Type,    LISTVIEW_KIND,
  476. /*                        LA_LabelID,    MSG_TERMPICKFILE_FILE_LIST_GAD,*/
  477.                         LA_Chars,    30,
  478.                         LA_ID,        GAD_LIST,
  479.                         LA_Lines,    10,
  480.                         LALV_MaxGrowX,    MaxWidth,
  481.                         LALV_MaxGrowY,    MaxHeight,
  482.                         LALV_ResizeY,    TRUE,
  483.                         GTLV_Labels,    FileList,
  484.                         GTLV_Selected,    Index,
  485.                         LALV_Link,    NIL_LINK,
  486.                         LALV_CursorKey,    TRUE,
  487.                     TAG_DONE);
  488.  
  489.                     LT_EndGroup(Handle);
  490.                 }
  491.  
  492.                 LT_New(Handle,
  493.                     LA_Type,VERTICAL_KIND,
  494.                 TAG_DONE);
  495.                 {
  496.                     LT_New(Handle,
  497.                         LA_Type,    XBAR_KIND,
  498.                         LAXB_FullSize,    TRUE,
  499.                     TAG_DONE);
  500.  
  501.                     LT_EndGroup(Handle);
  502.                 }
  503.  
  504.                 LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  505.                     LAGR_SameSize,    TRUE,
  506.                     LAGR_Spread,    TRUE,
  507.                 TAG_DONE);
  508.                 {
  509.                     LT_New(Handle,
  510.                         LA_Type,    BUTTON_KIND,
  511.                         LA_LabelID,    MSG_GLOBAL_USE_GAD,
  512.                         LA_ID,        GAD_USE,
  513.                         LABT_ReturnKey,    TRUE,
  514.                         LABT_ExtraFat,    TRUE,
  515.                     TAG_DONE);
  516.  
  517.                     LT_New(Handle,
  518.                         LA_Type,    BUTTON_KIND,
  519.                         LA_LabelID,    MSG_TERMPICKFILE_SELECT_GAD,
  520.                         LA_ID,        GAD_SELECT,
  521.                         LABT_ExtraFat,    TRUE,
  522.                     TAG_DONE);
  523.  
  524.                     LT_New(Handle,
  525.                         LA_Type,    BUTTON_KIND,
  526.                         LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  527.                         LA_ID,        GAD_CANCEL,
  528.                         LABT_EscKey,    TRUE,
  529.                         LABT_ExtraFat,    TRUE,
  530.                     TAG_DONE);
  531.  
  532.                     LT_EndGroup(Handle);
  533.                 }
  534.  
  535.                 LT_EndGroup(Handle);
  536.             }
  537.  
  538.             if(PanelWindow = LT_Build(Handle,
  539.                 LAWN_TitleText,        Prompt,
  540.                 LAWN_IDCMP,        IDCMP_CLOSEWINDOW,
  541.                 LAWN_HelpHook,        &GuideHook,
  542.                 LAWN_Parent,        Window,
  543.                 WA_DepthGadget,        TRUE,
  544.                 WA_CloseGadget,        TRUE,
  545.                 WA_DragBar,        TRUE,
  546.                 WA_RMBTrap,        TRUE,
  547.                 WA_Activate,        TRUE,
  548.                 WA_SimpleRefresh,    TRUE,
  549.             TAG_DONE))
  550.             {
  551.                 struct IntuiMessage    *Message;
  552.                 BOOLEAN             Done = FALSE;
  553.                 ULONG             MsgClass;
  554.                 UWORD             MsgCode;
  555.                 struct Gadget        *MsgGadget;
  556.  
  557.                 LT_ShowWindow(Handle,TRUE);
  558.  
  559.                 PushWindow(PanelWindow);
  560.  
  561.                 do
  562.                 {
  563.                     if(Wait(PORTMASK(PanelWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
  564.                         break;
  565.  
  566.                     while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  567.                     {
  568.                         MsgClass    = Message -> Class;
  569.                         MsgCode        = Message -> Code;
  570.                         MsgGadget    = (struct Gadget *)Message -> IAddress;
  571.  
  572.                         LT_ReplyIMsg(Message);
  573.  
  574.                         if(MsgClass == IDCMP_CLOSEWINDOW)
  575.                             Done = TRUE;
  576.  
  577.                         if(MsgClass == IDCMP_GADGETUP)
  578.                         {
  579.                             switch(MsgGadget -> GadgetID)
  580.                             {
  581.                                 case GAD_USE:
  582.  
  583.                                     if(Index != (ULONG)~0)
  584.                                     {
  585.                                         struct Node *Node = GetListNode(Index,FileList);
  586.  
  587.                                         if(Node)
  588.                                         {
  589.                                             strcpy(Name,Node -> ln_Name);
  590.  
  591.                                             Result = TRUE;
  592.                                         }
  593.                                     }
  594.  
  595.                                     Done = TRUE;
  596.                                     break;
  597.  
  598.                                 case GAD_CANCEL:
  599.  
  600.                                     Done = TRUE;
  601.                                     break;
  602.  
  603.                                 case GAD_LIST:
  604.  
  605.                                     Index = MsgCode;
  606.                                     break;
  607.  
  608.                                 case GAD_SELECT:
  609.  
  610.                                     SplitFileName(Name,&DummyChar,DummyBuffer);
  611.  
  612.                                     if(FileRequest = GetFile(PanelWindow,Prompt,DummyBuffer,DummyChar,DummyBuffer,Pattern,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  613.                                     {
  614.                                         STRPTR FileName;
  615.  
  616.                                         if(FileRequest -> fr_NumArgs > 1 && FileRequest -> fr_ArgList)
  617.                                             FileName = FileRequest -> fr_ArgList -> wa_Name;
  618.                                         else
  619.                                             FileName = FileRequest -> fr_File;
  620.  
  621.                                         if(!Stricmp(FileRequest -> fr_Drawer,Directory))
  622.                                             strcpy(Name,FileName);
  623.                                         else
  624.                                             strcpy(Name,DummyBuffer);
  625.  
  626.                                         if(Type != -1)
  627.                                         {
  628.                                             UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
  629.  
  630.                                             if(!Stricmp(FileRequest -> fr_Drawer,Directory))
  631.                                             {
  632.                                                 strcpy(LocalBuffer,Directory);
  633.  
  634.                                                 if(AddPart(LocalBuffer,Name,MAX_FILENAME_LENGTH))
  635.                                                     ValidateFile(LocalBuffer,Type,Name);
  636.                                             }
  637.                                             else
  638.                                             {
  639.                                                 if(ValidateFile(DummyBuffer,Type,LocalBuffer))
  640.                                                 {
  641.                                                     strcpy(Name,DummyBuffer);
  642.  
  643.                                                     DummyChar = PathPart(Name);
  644.  
  645.                                                     *DummyChar = 0;
  646.  
  647.                                                     AddPart(Name,LocalBuffer,MAX_FILENAME_LENGTH);
  648.                                                 }
  649.                                             }
  650.                                         }
  651.  
  652.                                         FreeAslRequest(FileRequest);
  653.  
  654.                                         Done = Result = TRUE;
  655.                                     }
  656.  
  657.                                     break;
  658.                             }
  659.                         }
  660.  
  661.                         if(MsgClass == IDCMP_IDCMPUPDATE)
  662.                         {
  663.                             struct Node *Node = GetListNode(Index = MsgCode,FileList);
  664.  
  665.                             if(Node)
  666.                             {
  667.                                 strcpy(Name,Node -> ln_Name);
  668.  
  669.                                 Done = Result = TRUE;
  670.  
  671.                                 LT_PressButton(Handle,GAD_USE);
  672.                             }
  673.                         }
  674.                     }
  675.                 }
  676.                 while(!Done);
  677.  
  678.                 PopWindow();
  679.             }
  680.  
  681.             LT_DeleteHandle(Handle);
  682.         }
  683.  
  684.         DeleteList(FileList);
  685.     }
  686.     else
  687.     {
  688.         SplitFileName(Name,&DummyChar,DummyBuffer);
  689.  
  690.         if(FileRequest = GetFile(Window,Prompt,DummyBuffer,DummyChar,DummyBuffer,Pattern,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  691.         {
  692.             STRPTR FileName;
  693.  
  694.             if(FileRequest -> fr_NumArgs > 1 && FileRequest -> fr_ArgList)
  695.                 FileName = FileRequest -> fr_ArgList -> wa_Name;
  696.             else
  697.                 FileName = FileRequest -> fr_File;
  698.  
  699.             if(!Stricmp(FileRequest -> fr_Drawer,Directory))
  700.                 strcpy(Name,FileName);
  701.             else
  702.                 strcpy(Name,DummyBuffer);
  703.  
  704.             if(Type != -1)
  705.             {
  706.                 UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
  707.  
  708.                 if(!Stricmp(FileRequest -> fr_Drawer,Directory))
  709.                 {
  710.                     strcpy(LocalBuffer,Directory);
  711.  
  712.                     if(AddPart(LocalBuffer,Name,MAX_FILENAME_LENGTH))
  713.                         ValidateFile(LocalBuffer,Type,Name);
  714.                 }
  715.                 else
  716.                 {
  717.                     if(ValidateFile(DummyBuffer,Type,LocalBuffer))
  718.                     {
  719.                         strcpy(Name,DummyBuffer);
  720.  
  721.                         DummyChar = PathPart(Name);
  722.  
  723.                         *DummyChar = 0;
  724.  
  725.                         AddPart(Name,LocalBuffer,MAX_FILENAME_LENGTH);
  726.                     }
  727.                 }
  728.             }
  729.  
  730.             FreeAslRequest(FileRequest);
  731.  
  732.             return(TRUE);
  733.         }
  734.     }
  735.  
  736.     return(Result);
  737. }
  738.